// 展示了async/await是如何利用Promise对象和generator函数生成器来实现异步操作的：
function asyncToGenerator1(generatorFunc) {
  return function () {
    // 调用generator函数，生成一个迭代器对象
    const gen = generatorFunc.apply(this, arguments);

    // 定义一个递归函数，用于在异步操作完毕后继续执行generator函数
    function step(nextF) {
      let next;

      try {
        // 调用异步操作函数，并返回一个Promise对象
        next = nextF();
      } catch (e) {
        // 如果异步操作抛出错误，则直接将错误信息包装成rejected状态的Promise对象，并且通过迭代器对象的throw方法来抛出错误
        return Promise.reject(e);
      }

      // 如果异步操作已经完成（Promise对象状态为resolved），则直接返回异步操作结果，并且通过迭代器对象的next方法继续执行generator函数
      if (next.done) {
        return Promise.resolve(next.value);
      }

      // 将Promise对象的then方法作为回调函数传入，等待异步操作结果
      return Promise.resolve(next.value).then((result) => {
        // 在异步操作完成后，通过迭代器对象的next方法继续执行generator函数，并将异步操作的结果传入
        return step(function () {
          return gen.next(result);
        });
      }, (err) => {
        // 如果异步操作返回rejected状态，则通过迭代器对象的throw方法来抛出错误
        return step(function () {
          return gen.throw(err);
        });
      });
    }

    // 启动递归函数
    return step(function () {
      return gen.next(undefined);
    });
  };
}
function asyncToGenerator(fn) {
  return function () {
    var gen = fn.apply(this, arguments);

    function handle(result) {
      if (result.done) {
        return Promise.resolve(result.value);
      }

      return Promise.resolve(result.value)
        .then(function (res) {
          return handle(gen.next(res));
        }, function (err) {
          return handle(gen.throw(err));
        });
    }

    try {
      return handle(gen.next());
    } catch (ex) {
      return Promise.reject(ex);
    }
  };
}
// 立即执行generator函数
function asyncToGenerator3 (fn) {
  let generator = fn()
  return new Promise((resolve,reject)=>{
    function handle(result) {
      if (result.done) {
        resolve(result.value)
      }
      return Promise.resolve(result.value).then((res)=>{
        handle(generator.next(res))
      },(error)=>{
        reject(error)
      })
    }
    try {
      handle(generator.next())
    } catch (error) {
      reject(error)
    }
  })
}
// 定义一个异步操作的函数
function asyncFn() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve('hello');
    }, 1000);
  });
}
function asyncFn2() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(' world');
    }, 1000);
  });
}

function* generatorFn() {
  const result = yield asyncFn();
  const result2 = yield asyncFn2();
  return result + result2
};

// // 将generator函数传入asyncToGenerator函数中，生成一个返回Promise对象的异步函数
// const asyncFnWrapper = asyncToGenerator(generatorFn);
// // 调用异步函数，并通过Promise对象的then方法获取结果。此时generator函数中所有的异步操作都已经完成，控制台输出'hello world'
// asyncFnWrapper().then((result) => {
//   console.log(result);
// });
asyncToGenerator3(generatorFn).then(res => {
  
  console.log('res',res)
})


/* 自己手写 */
function* generatorFn () {
  let v1 = yield new Promise((resolve)=>{
      setTimeout(() => {
          resolve(1)
      }, 200);
  })
  let v2 = yield new Promise((resolve)=>{
      setTimeout(() => {
          resolve(1)
      }, 200);
  })
  return v1 + v2
}
function asyncToGenerator (generatorFn) {
  let gen = generatorFn()
  return new Promise((resolve,reject) => {
      let recusion = ( {value,done})=> {
          if (done) {
              resolve(value)
          } else {
              Promise.resolve(value).then(res => {
                  recusion(gen.next(res))
              },(error)=>{
                  reject(error)
              })
          }
      }
      try {
          recusion(gen.next())
      } catch (error) {
          reject(error)
      }
  })

}
asyncToGenerator(generatorFn).then(res => {
  console.log('res',res)
})